package com.qfedu.entity.chapter2.course08;

import java.util.Collection;
import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHash<T> {
    /**
     * 虚拟节点个数
     */
    private final int VIRTUAL_NODE_NUM;
    /**
     * 一致性Hash环
     * 虚拟节点分配,key是hash值,value是虚拟节点服务器名称
     */
    private final SortedMap<Integer, T> circle = new TreeMap<>();

    /**
     * 构造，使用Java默认的Hash算法
     *
     * @param virtualNodeNum 增加每个节点的虚拟节点有利于负载均衡
     * @param nodes          真实节点列表
     */
    public ConsistentHash(int virtualNodeNum, Collection<T> nodes) {
        this.VIRTUAL_NODE_NUM = virtualNodeNum;
        //初始化节点
        for (T node : nodes) {
            add(node);
        }
    }

    /**
     * 改进的32位FNV HASH算法
     *
     * @param data 字符串
     * @return hash结果
     */
    private int getHash(String data) {
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for (int i = 0; i < data.length(); i++) {
            hash = (hash ^ data.charAt(i)) * p;
        }
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        //如果算出来的值为负数则取其绝对值
        return Math.abs(hash);
    }


    /**
     * 增加节点<br> 每增加一个节点，就会在闭环上增加给定复制节点数<br> 例如复制节点数是2，则每调用此方法一次，增加两个虚拟节点，这两个节点指向同一Node
     * 由于hash算法会调用node的toString方法，故按照toString去重
     *
     * @param node 节点对象
     */
    public void add(T node) {
        //System.out.println("真实节点[" + node + "]上线添加");
        for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
            int hash = getHash(node.toString() + i);
            circle.put(hash, node);
            //System.out.println("虚拟节点[" + node.toString() + i + "],hash:" + hash + "被添加");
        }
    }

    /**
     * 移除节点的同时移除相应的虚拟节点
     *
     * @param node 节点对象
     */
    public void remove(T node) {
        //System.out.println("真实节点[" + node + "]下线移除");
        for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
            int hash = getHash(node.toString() + i);
            circle.remove(hash);
            //System.out.println("虚拟节点[" + node.toString() + i + "],hash:" + hash + "被删除");
        }
    }

    /**
     * 获得一个最近的顺时针节点
     * 为给定键取Hash，取得顺时针方向上最近的一个虚拟节点对应的实际节点
     *
     * @param key
     * @return 节点对象
     */
    public T get(Object key) {
        if (circle.isEmpty()) {
            return null;
        }
        int hash = getHash(key.toString());
        if (!circle.containsKey(hash)) {
            //返回此映射的部分视图，其键大于等于 hash
            SortedMap<Integer, T> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        //正好命中
        return circle.get(hash);
    }
}